import os
import pandas as pd 
import numpy as np 
import seaborn as sns
import matplotlib.pyplot as plt
import cv2 
import tensorflow as tf
import random
import shutil             # to copy images to another directory 
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report , confusion_matrix

from tqdm import tqdm
from keras.layers import Conv2D, MaxPooling2D , BatchNormalization ,Dropout ,Flatten , Dense , Input , Rescaling , Resizing
from keras.models import Sequential
from tensorflow.keras.preprocessing.image import ImageDataGenerator, array_to_img, img_to_array, load_img
from tensorflow.keras.applications import MobileNetV2

import warnings

with warnings.catch_warnings():
    warnings.simplefilter("ignore")
    
plt.style.use('ggplot')

2024-11-02 17:37:23.776857: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:485] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered
2024-11-02 17:37:23.790738: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:8454] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered
2024-11-02 17:37:23.794846: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1452] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered
2024-11-02 17:37:23.805597: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.
To enable the following instructions: AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.
2024-11-02 17:37:25.240955: W tensorflow/compiler/tf2tensorrt/utils/py_utils.cc:38] TF-TRT Warning: Could not find TensorRT

# dataDirList indicmaos la ubicacion de los datos.
dataDirList = ['/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Diplo/DataSet/Dataset_splits/']

#selectedClasses definimos las clases específicas que el modelo deberá reconocer.
selectedClasses = ['cardboard', 'compost', 'glass', 'metal', 'paper', 'plastic', 'trash']

imgPaths = []
labels = []
for dataDir in dataDirList:
    for className in os.listdir(dataDir):
        if className in selectedClasses :
            classPath = os.path.join(dataDir,className)
            for img in os.listdir(classPath):
                imgPath = os.path.join(classPath,img)
                imgPaths.append(imgPath)
                labels.append(className)
            
# Se convierte imgPaths y labels en un DataFrame df, con dos columnas: 'imgPath' para las rutas de las imágenes y 'label' para las etiquetas de clase.
df = pd.DataFrame({
    'imgPath':imgPaths,
    'label':labels
})
# Se reorganiza aleatoriamente df y se restablecen los índices
# sirve para:
#            Evitar sesgo en el orden de las clases:  Aleatorizar las filas asegura que todas las clases estén distribuidas al azar.
#            Preparar para entrenamiento: permite obtener subconjuntos más representativos de las clases para cada uno de estos conjuntos.Train,Test,Validacion
#            Consistencia de índices: se asegura que el DataFrame tenga un índice continuo, útil en análisis y modelos que dependen de un acceso estructurado y ordenado a las filas.
df = df.sample(frac=1).reset_index(drop=True)            # Shuffle

df

# obtemos la proporción de manera que el ratio de cada clase sea para entranamiento y el restante para pruebas 
# ej. si ratio es 0.8 significa 80% para entranamiento y 20% para pruebas.
def DataFrameSpliting(df , ratio , classesList):
    
    trainDf = pd.DataFrame(columns = ['imgPath','label'])
    testDf = pd.DataFrame(columns = ['imgPath','label'])
    for clas in classesList :
        tempDf = df[df['label'] == clas]
        lastIndex = int(len(tempDf) * ratio)
        trainClassDf = tempDf[:lastIndex]
        testClassDf = tempDf[lastIndex:]
        trainDf = pd.concat([trainDf , trainClassDf] , axis=0)
        testDf = pd.concat([testDf , testClassDf] , axis=0)
    
    # Aleatorizamos (sample(frac=1)) y restablecemos los índices (reset_index(drop=True)) de ambos DataFrames, para que estén en orden sin sesgo de clase ni saltos en los índices.         
    return trainDf.sample(frac=1).reset_index(drop=True) , testDf.sample(frac=1).reset_index(drop=True)  # shuffling , reset index

# Extraemos las clases únicas en la columna label del DataFrame df
classList = list(df['label'].unique())

# Dividimos el DataFrame en entrenamiento y prueba. 
# trainDf: contendrá el 85% de los datos de cada clase. testDf: contendrá el 15% restante de cada clase. 
trainDf , testDf = DataFrameSpliting(df , 0.85 , classList)

trainDf

trainDf['label'].value_counts()

label
compost      929
paper        921
glass        921
trash        880
cardboard    861
plastic      823
metal        712
Name: count, dtype: int64

testDf

testDf['label'].value_counts()

label
compost      164
glass        163
paper        163
trash        156
cardboard    152
plastic      146
metal        126
Name: count, dtype: int64

imgPaths = df['imgPath']
fig, axs = plt.subplots(3, 8, figsize=(25, 10))

axs = axs.flatten()

for ax,imgPath in zip(axs , imgPaths):
    label = str(imgPath).split('/')[-2]    # extract label of an imgae from a path 
    img = cv2.imread(imgPath)
    ax.imshow(img)
    ax.set_title(label)
    ax.axis('off')
    
plt.tight_layout()
plt.show()

datagenTrain = ImageDataGenerator(
      rescale=1./255,    # Escala los valores de píxeles de las imágenes al rango [0,1] dividiendo cada valor por 255. 
                  # Esto es útil para normalizar los datos de imágenes, ya que los modelos suelen funcionar mejor con valores de entrada en este rango. 
      zoom_range=(1.0, 1.2), # Aplica un aumento aleatorio de zoom en cada imagen. 
                  # En este caso, 1.0 significa sin zoom y 1.2 representa un zoom máximo del 120%
                  # Esto ayuda a que el modelo sea más robusto frente a imágenes de diferentes tamaños y proporciones.
      horizontal_flip=True, # Realiza una inversión horizontal aleatoria de la imagen (de izquierda a derecha). 
      vertical_flip=True, # Realiza una inversión vertical aleatoria de la imagen (de arriba a abajo).
      rotation_range=45, # Rota la imagen aleatoriamente hasta un máximo de 45 grados en cualquier dirección (en sentido horario o antihorario).
)

# Define el tamaño objetivo de las imágenes para redimensionarlas uniformemente a (224, 224) píxeles.
# Nos aseguramos que todas las imágenes tengan el mismo tamaño cuando se alimenta al modelo.
IMG_SIZE = (224,224)

trainGenerator = datagenTrain.flow_from_dataframe(
    trainDf ,  # dataset de entrenamiento
    x_col='imgPath',
    y_col='label',
    target_size=IMG_SIZE,      # Redimensiona las imágenes de prueba a (224, 224). 
    batch_size=64 ,            # Genera 64 imágenes del datagenTrain (invertidas, rotadas, con zoom, etc.) de una vez.
    class_mode='categorical'   # Clasifica las etiquetas en formato categórico (necesario para clasificación multiclase).
)

# Generador de datos de prueba, configurado con un aumento mínimo:
datagenTest = ImageDataGenerator( rescale=1./255 ) # Normaliza las imágenes escalándolas al rango [0, 1].
                                     # No se aplican otras transformaciones (sin rotaciones ni volteos), lo cual es habitual para el conjunto de prueba.

# Generador de datos de prueba:
testGenerator = datagenTest.flow_from_dataframe(
    testDf ,     # dataset de test
    x_col='imgPath',
    y_col='label',
    target_size=IMG_SIZE,  # Redimensiona las imágenes de prueba a (224, 224). 
    batch_size=8 ,         # Genera lotes de 8 imágenes.
    class_mode='categorical', # Clasificación multiclase para el conjunto de prueba.
    shuffle=False  # No se mezcla el conjunto de prueba, preservando el orden original para comparaciones de resultados.
)

# Imprimimos el número total de muestras en los conjuntos de entrenamiento y prueba (trainGenerator.samples y testGenerator.samples).
# Vemos el tamaño de cada conjunto.
print(f"Training set size: {trainGenerator.samples}")
print(f"Testing set size: {testGenerator.samples}")

Found 6040 validated image filenames belonging to 7 classes.

/home/edgardo/miniconda3/envs/py310/lib/python3.10/site-packages/keras/src/legacy/preprocessing/image.py:920: UserWarning: Found 7 invalid image filename(s) in x_col="imgPath". These filename(s) will be ignored.
  warnings.warn(

Found 1070 validated image filenames belonging to 7 classes.
Training set size: 6040
Testing set size: 1070

Model = Sequential([
    MobileNetV2(weights='imagenet', include_top=False, input_shape=(224,224,3)), 
    # Utiliza pesos preentrenados de ImageNet, lo que significa que el modelo ya ha aprendido a identificar características generales de las 
    # imágenes durante su entrenamiento en ese conjunto de datos.
    # include_top=False, significa que se omiten las capas de clasificación final del modelo original MobileNetV2, 
    # lo que permite personalizar la parte superior del modelo para una tarea específica (en este caso, clasificación de residuos).
    # input_shape=(224,224,3) define la forma de entrada del modelo, se especifica que las imágenes de entrada deben ser de 224 píxeles de 
    # ancho por 224 píxeles de alto y tener 3 canales (RGB).
    
    Flatten(),  # Esta capa convierte la salida 2D de las capas convolucionales anteriores en un vector 1D. Esto es necesario para que la salida 
    # se pueda pasar a las capas densas (fully connected).
    # Ignora las capas de flatten y dense cuando include_top = False 
    
    Dense(64, activation='relu'), # Añade una capa densa (o fully connected) con 64 neuronas. La función de activación ReLU (Rectified Linear Unit) 
    # se utiliza para introducir no linealidad, lo que ayuda al modelo a aprender relaciones complejas en los datos.
    
    BatchNormalization(), # Normaliza las salidas de la capa anterior para mejorar la estabilidad y la velocidad del entrenamiento. 
    # Esto ayuda a mitigar problemas relacionados con la variación de covariables.
    
    Dropout(0.08), # Añade una capa de Dropout, que apaga aleatoriamente el 8% de las neuronas durante el entrenamiento. 
    # Esto ayuda a prevenir el sobreajuste, lo que significa que el modelo se generaliza mejor a nuevos datos.
    
    Dense(7, activation='softmax') # Esta es la capa de salida del modelo, que tiene 7 neuronas, cada una representando una de las categorías 
    # de clasificación (en este caso, 7 tipos de residuos).
    # activation='softmax' se utiliza para que las salidas de las neuronas representen probabilidades. 
])

WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
I0000 00:00:1730579920.624575   25294 cuda_executor.cc:1001] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node
Your kernel may have been built without NUMA support.
2024-11-02 17:38:40.708561: W tensorflow/core/common_runtime/gpu/gpu_device.cc:2343] Cannot dlopen some GPU libraries. Please make sure the missing libraries mentioned above are installed properly if you would like to use GPU. Follow the guide at https://www.tensorflow.org/install/gpu for how to download and setup the required libraries for your platform.
Skipping registering GPU devices...

preTrainedModel = Model.layers[0] # Esta línea extrae la primera capa del modelo Model, que se supone que es el modelo preentrenado (en este caso, MobileNetV2). El modelo preentrenado se asigna a la variable preTrainedModel.
for layer in preTrainedModel.layers[:-4]:    # "Congelamos todas las capas excepto las primeras y las últimas 3 capas; las haremos entrenables (los pesos cambian con el entrenamiento)."
    layer.trainable = False # se establece que estas capas no son entrenables (es decir, sus pesos no se actualizarán durante el entrenamiento).

Model.compile(optimizer='adam',loss='categorical_crossentropy' ,metrics=['accuracy'])
# optimizer='adam' especifica el optimizador que se usará para actualizar los pesos del modelo durante el entrenamiento.
# Utilizamos el optimizador Adam, que es uno de los optimizadores más populares. 
# Adam combina las ventajas de dos métodos: AdaGrad y RMSProp, y es conocido por su efectividad en una amplia variedad de tareas 
# de aprendizaje automático.

# loss='categorical_crossentropy' define la función de pérdida que se utilizará para evaluar la calidad de las predicciones del modelo.
# categorical_crossentropy es adecuada para problemas de clasificación multiclase donde las etiquetas son categorías distintas.
# Esta función mide la disimilitud entre la distribución de probabilidad predicha y la verdadera distribución de probabilidad de las clases. 
# Se usa comúnmente cuando las etiquetas son representadas como matrices de clase one-hot (es decir, un formato donde cada etiqueta se convierte
# en un vector que tiene 1 en la posición de la clase y 0 en otras).

# metrics=['accuracy'] especifica las métricas que se desean observar durante el entrenamiento y la evaluación del modelo.
# Utilizamos precisión (accuracy) como métrica, que mide la proporción de predicciones correctas sobre el total de predicciones realizadas.

# entrenamos el modelo con los datos proporcionados. Este método devuelve un objeto History que contiene información sobre el entrenamiento, 
# como las pérdidas y las métricas a lo largo de las épocas.
history = Model.fit(
             # Este es el generador de datos que proporciona las imágenes de entrenamiento y sus etiquetas en lotes (batches) durante el entrenamiento.
             trainGenerator, 
             # especifica un generador de datos para la validación, que se utilizará para evaluar el modelo después de cada época. 
             # En este caso, testGenerator proporciona las imágenes y etiquetas de prueba.
             validation_data = testGenerator,  
             # Establece el número de épocas para el entrenamiento. 
             epochs=50,
             
#            batch_size=64,   # we define it above inside trainGenerator
             # Controla la cantidad de información que se muestra durante el entrenamiento. verbose=1 significa que se imprimirá una barra de 
             # progreso en cada época, mostrando información como la pérdida y la precisión.
             verbose=1,
             # se especifica que utilice callbacks, que son funciones que se pueden ejecutar en puntos específicos durante el entrenamiento.
             # EarlyStopping, que detiene el entrenamiento si la métrica monitorizada (en este caso, la precisión de validación val_accuracy) 
             # no mejora después de un número específico de épocas (definido por patience=4). 
             # Esto ayuda a evitar el sobreajuste (overfitting) al detener el entrenamiento cuando el modelo ya no mejora.
             # restore_best_weights=True asegura que, al final del entrenamiento, el modelo restaurará los pesos de la mejor época, es decir,
             # los pesos en los que se obtuvo la mejor precisión de validación, en lugar de usar los pesos del final del entrenamiento.
             callbacks=[tf.keras.callbacks.EarlyStopping(
                            patience=4,
                            monitor='val_accuracy',
                            restore_best_weights=True)])

/home/edgardo/miniconda3/envs/py310/lib/python3.10/site-packages/keras/src/trainers/data_adapters/py_dataset_adapter.py:121: UserWarning: Your `PyDataset` class should call `super().__init__(**kwargs)` in its constructor. `**kwargs` can include `workers`, `use_multiprocessing`, `max_queue_size`. Do not pass these arguments to `fit()`, as they will be ignored.
  self._warn_if_super_not_called()

Epoch 1/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 167s 2s/step - accuracy: 0.6896 - loss: 0.9393 - val_accuracy: 0.8290 - val_loss: 0.5396
Epoch 2/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 165s 2s/step - accuracy: 0.8658 - loss: 0.3913 - val_accuracy: 0.8748 - val_loss: 0.3973
Epoch 3/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 170s 2s/step - accuracy: 0.8962 - loss: 0.3050 - val_accuracy: 0.8776 - val_loss: 0.4191
Epoch 4/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 175s 2s/step - accuracy: 0.9193 - loss: 0.2522 - val_accuracy: 0.8832 - val_loss: 0.3677
Epoch 5/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 170s 2s/step - accuracy: 0.9289 - loss: 0.2141 - val_accuracy: 0.8757 - val_loss: 0.3856
Epoch 6/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 159s 2s/step - accuracy: 0.9447 - loss: 0.1641 - val_accuracy: 0.8860 - val_loss: 0.3792
Epoch 7/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 162s 2s/step - accuracy: 0.9514 - loss: 0.1462 - val_accuracy: 0.8925 - val_loss: 0.3920
Epoch 8/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 160s 2s/step - accuracy: 0.9536 - loss: 0.1422 - val_accuracy: 0.8925 - val_loss: 0.3890
Epoch 9/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 158s 2s/step - accuracy: 0.9629 - loss: 0.1192 - val_accuracy: 0.9047 - val_loss: 0.3665
Epoch 10/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 160s 2s/step - accuracy: 0.9570 - loss: 0.1240 - val_accuracy: 0.8925 - val_loss: 0.4004
Epoch 11/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 158s 2s/step - accuracy: 0.9653 - loss: 0.0997 - val_accuracy: 0.9150 - val_loss: 0.3810
Epoch 12/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 158s 2s/step - accuracy: 0.9779 - loss: 0.0758 - val_accuracy: 0.9056 - val_loss: 0.3890
Epoch 13/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 159s 2s/step - accuracy: 0.9663 - loss: 0.1027 - val_accuracy: 0.8953 - val_loss: 0.4588
Epoch 14/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 159s 2s/step - accuracy: 0.9720 - loss: 0.0780 - val_accuracy: 0.9075 - val_loss: 0.4054
Epoch 15/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 159s 2s/step - accuracy: 0.9776 - loss: 0.0728 - val_accuracy: 0.9159 - val_loss: 0.3994
Epoch 16/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 159s 2s/step - accuracy: 0.9782 - loss: 0.0663 - val_accuracy: 0.9009 - val_loss: 0.4280
Epoch 17/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 160s 2s/step - accuracy: 0.9787 - loss: 0.0623 - val_accuracy: 0.9065 - val_loss: 0.4386
Epoch 18/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 158s 2s/step - accuracy: 0.9726 - loss: 0.0662 - val_accuracy: 0.9093 - val_loss: 0.4124
Epoch 19/50
95/95 ━━━━━━━━━━━━━━━━━━━━ 158s 2s/step - accuracy: 0.9775 - loss: 0.0640 - val_accuracy: 0.9131 - val_loss: 0.4369

Model.summary()

Model: "sequential_1"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ mobilenetv2_1.00_224            │ (None, 7, 7, 1280)     │     2,257,984 │
│ (Functional)                    │                        │               │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten_1 (Flatten)             │ (None, 62720)          │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_2 (Dense)                 │ (None, 64)             │     4,014,144 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ batch_normalization_1           │ (None, 64)             │           256 │
│ (BatchNormalization)            │                        │               │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dropout_1 (Dropout)             │ (None, 64)             │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_3 (Dense)                 │ (None, 7)              │           455 │
└─────────────────────────────────┴────────────────────────┴───────────────┘

 Total params: 15,127,895 (57.71 MB)

 Trainable params: 4,427,527 (16.89 MB)

 Non-trainable params: 1,845,312 (7.04 MB)

 Optimizer params: 8,855,056 (33.78 MB)

plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'validation'], loc='upper left')
plt.show()

predictions = Model.predict(testGenerator)

134/134 ━━━━━━━━━━━━━━━━━━━━ 18s 129ms/step

trainGenerator.class_indices

{'cardboard': 0,
 'compost': 1,
 'glass': 2,
 'metal': 3,
 'paper': 4,
 'plastic': 5,
 'trash': 6}

trueClasses = testGenerator.classes
trueClasses[:10]

[3, 6, 6, 2, 4, 4, 4, 2, 3, 5]

predictedClasses = predictions.argmax(axis=-1)
predictedClasses[:10]

array([3, 6, 6, 2, 5, 4, 4, 2, 3, 5])

test_loss, test_accuracy = Model.evaluate(testGenerator)
test_accuracy

134/134 ━━━━━━━━━━━━━━━━━━━━ 16s 120ms/step - accuracy: 0.8973 - loss: 0.4280

0.8981308341026306

CM = confusion_matrix(trueClasses, predictedClasses)
sns.heatmap(CM, center = True,cmap='terrain',annot=True ,fmt='.5g')
plt.show()

cm_df = pd.DataFrame(CM, index=trainGenerator.class_indices.keys(), columns=trainGenerator.class_indices.keys())
cm_df.to_csv('matriz_confusion.csv', index=True)

ClassificationReport = classification_report(trueClasses, predictedClasses)
print('Classification Report is : \n', ClassificationReport )

Classification Report is : 
               precision    recall  f1-score   support

           0       0.94      0.89      0.92       152
           1       0.98      0.93      0.95       164
           2       0.89      0.91      0.90       163
           3       0.91      0.89      0.90       126
           4       0.95      0.91      0.93       163
           5       0.84      0.79      0.81       146
           6       0.80      0.95      0.87       156

    accuracy                           0.90      1070
   macro avg       0.90      0.90      0.90      1070
weighted avg       0.90      0.90      0.90      1070

images = []
predictedClasses = []
trueClasses = []


class_labels = list(testGenerator.class_indices.keys())

for i in range(len(testGenerator)):
    img_batch, true_labels_batch = next(testGenerator)  # Get next batch
    true_class_idx = np.argmax(true_labels_batch[0])  # Get the true class index
    
    # Predict the class for the image
    prediction = Model.predict(img_batch)
    predicted_class_idx = np.argmax(prediction[0])  # Get the predicted class index
    
    # Convert the class indices to class labels
    predicted_class = class_labels[predicted_class_idx]
    true_class = class_labels[true_class_idx]
    
    images.append(np.squeeze(img_batch[0]))
    predictedClasses.append(predicted_class)
    trueClasses.append(true_class)
    
    if i >= 24:  # For example, only plot 24 images
        break

1/1 ━━━━━━━━━━━━━━━━━━━━ 1s 921ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 126ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 127ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 130ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 129ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 143ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 136ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 128ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 123ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 122ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 124ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 123ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 119ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 126ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 117ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 118ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 125ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 144ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 136ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 118ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 121ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 128ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 139ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 144ms/step
1/1 ━━━━━━━━━━━━━━━━━━━━ 0s 139ms/step

fig, axs = plt.subplots(3, 8, figsize=(25, 10))


axs = axs.flatten()

for ax,img , pred , true in zip(axs , images , predictedClasses , trueClasses):
    ax.imshow(img)
    ax.set_title(f"Pred: {pred}, True: {true}" ,fontsize=14)
    ax.axis('off')
    
plt.tight_layout()
plt.show()

Model.save('/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Diplo/Tensorflow2/model_NoHayPlanetaB_tf2.keras')

Model.save_weights('/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Diplo/Tensorflow2/model_NoHayPlanetaB.weights.h5')

Sistema para la clasificación correcta de residuos.¶

Integrantes:¶

Tabla de contenidos
¶

¶

1.1 Paquetes y Bibliotecas ToC ¶

1.2. Cargar los Datos¶

2. Division
¶

3. Exploracion de Datos
¶

4. Aumento de Datos
¶

5. Modelado
¶

Entrenamos el modelo previamente definido en Keras.¶

6. Evaluacion
¶

1. Clasificación General¶

2. Detalles por Clase¶

3. Observaciones Generales¶

4. Recomendaciones¶

7. Imagenes Predecidas
¶

¶

	imgPath	label
0	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	paper
1	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	cardboard
2	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	compost
3	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	metal
4	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	compost
...	...	...
7112	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	cardboard
7113	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	trash
7114	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	paper
7115	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	glass
7116	/mnt/c/Users/edgardo/git-edgardo/Austral/TF-Di...	paper

Sistema para la clasificación correcta de residuos.¶

Integrantes:¶

Tabla de contenidos¶

¶

1.1 Paquetes y Bibliotecas ToC¶

1.2. Cargar los Datos¶

2. Division¶

3. Exploracion de Datos¶

4. Aumento de Datos¶

5. Modelado¶

Entrenamos el modelo previamente definido en Keras.¶

6. Evaluacion¶

1. Clasificación General¶

2. Detalles por Clase¶

3. Observaciones Generales¶

4. Recomendaciones¶

7. Imagenes Predecidas¶

¶

Tabla de contenidos
¶

1.1 Paquetes y Bibliotecas ToC ¶

2. Division
¶

3. Exploracion de Datos
¶

4. Aumento de Datos
¶

5. Modelado
¶

6. Evaluacion
¶

7. Imagenes Predecidas
¶